home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Collections: Scope
/
Scope Disk #213 (199x)(Scope PD)(US)[WB].zip
/
Scope Disk #213 (199x)(Scope PD)(US)[WB].adf
/
MAKER
/
GADGET.C
< prev
next >
Wrap
C/C++ Source or Header
|
1978-10-24
|
23KB
|
919 lines
#include "maker.h"
#include "proto.h"
#include "global.h"
#include <libraries/gadtools.h>
#include <graphics/gfxmacros.h>
#include <intuition/gadgetclass.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <proto/exec.h>
#include <proto/gadtools.h>
#include <string.h>
#define CYCLE_XWIDTH 28
#define MX_XWIDTH 28
USHORT CalcMaxWidth(char **theStrings);
void NewObj(USHORT code)
{
BOOL refresh = FALSE;
USHORT objType;
LinkNode *nodePtr = 0L;
switch (code)
{
case ITEM_NewButton:
objType = OTYPE_Button;
break;
case ITEM_NewCycle:
objType = OTYPE_Cycle;
break;
case ITEM_NewSlider:
objType = OTYPE_Slider;
break;
case ITEM_NewScroller:
objType = OTYPE_Scroller;
break;
case ITEM_NewMX:
objType = OTYPE_MX;
break;
case ITEM_NewCheckBox:
objType = OTYPE_CheckBox;
break;
case ITEM_NewString:
objType = OTYPE_String;
break;
case ITEM_NewPalette:
objType = OTYPE_Palette;
break;
case ITEM_NewListView:
objType = OTYPE_ListView;
break;
case ITEM_NewRect:
objType = OTYPE_Rect;
break;
case ITEM_NewLine:
objType = OTYPE_Line;
break;
case ITEM_NewText:
objType = OTYPE_Text;
break;
case ITEM_NewIText:
objType = OTYPE_IText;
break;
}
nodePtr = AllocateObj(objType);
if (!nodePtr)
return;
if (MakeGadget(nodePtr) != 2)
{
gSelObj = nodePtr;
refresh = TRUE;
}
else
{
// the operation failed, so nuke the object
DisposeObj(nodePtr);
}
if (!gEditMode) // if we're not in edit mode, don't highlight the new object
gSelObj = 0L;
if (refresh)
ReDraw();
}
/* Allocate the specified object type, and initialize it to default values */
LinkNode *AllocateObj( USHORT objType )
{
LinkNode *nodePtr = 0L;
switch (objType)
{
case OTYPE_Button:
{
ButtonObj *newButton = 0L;
if (GetMem( (void **) &newButton, sizeof(ButtonObj)))
{
strcpy(newButton->label, "Push Me");
newButton->type = OTYPE_Button;
newButton->numBytes = sizeof(ButtonObj);
newButton->rect.minX = 20;
newButton->rect.minY = 20;
newButton->rect.maxX = 83;
newButton->rect.maxY = 31;
newButton->flags = PLACETEXT_IN;
nodePtr = (LinkNode *) newButton;
}
}
break;
case OTYPE_Cycle:
{
CycleObj *newCycle = 0L;
if (GetMem( (void **) &newCycle, sizeof(CycleObj)))
{
strcpy(newCycle->label, "Cycle:");
newCycle->type = OTYPE_Cycle;
newCycle->numBytes = sizeof(CycleObj);
newCycle->textLabels = gDefaultMX;
newCycle->rect.minX = 20;
newCycle->rect.minY = 20;
newCycle->rect.maxX = newCycle->rect.minX + CYCLE_XWIDTH +
CalcMaxWidth(newCycle->textLabels) - 1;
newCycle->rect.maxY = 31;
newCycle->flags = PLACETEXT_LEFT;
newCycle->activeItem = 0;
nodePtr = (LinkNode *) newCycle;
}
}
break;
case OTYPE_Slider:
{
SliderObj *newSlider = 0L;
if (GetMem( (void **) &newSlider, sizeof(SliderObj)))
{
strcpy(newSlider->label, "Slider:");
newSlider->type = OTYPE_Slider;
newSlider->numBytes = sizeof(SliderObj);
newSlider->rect.minX = 20;
newSlider->rect.minY = 20;
newSlider->rect.maxX = 83;
newSlider->rect.maxY = 31;
newSlider->flags = PLACETEXT_ABOVE;
newSlider->minLevel = 0;
newSlider->maxLevel = 10;
newSlider->currentLevel = 0;
newSlider->maxChars = 10;
strcpy(newSlider->format, "%ld");
newSlider->levelPlace = PLACETEXT_LEFT;
newSlider->orientation = LORIENT_HORIZ;
newSlider->immediateMsg = FALSE;
newSlider->releaseMsg = TRUE;
nodePtr = (LinkNode *) newSlider;
}
}
break;
case OTYPE_Scroller:
{
ScrollerObj *newScroller = 0L;
if (GetMem( (void **) &newScroller, sizeof(ScrollerObj)))
{
strcpy(newScroller->label, "Scroller:");
newScroller->type = OTYPE_Scroller;
newScroller->numBytes = sizeof(ScrollerObj);
newScroller->rect.minX = 20;
newScroller->rect.minY = 20;
newScroller->rect.maxX = 35;
newScroller->rect.maxY = 89;
newScroller->flags = PLACETEXT_RIGHT;
newScroller->topItem = 0;
newScroller->totalItems = 10;
newScroller->visibleItems = 4;
newScroller->arrowSize = 12;
newScroller->orientation = LORIENT_VERT;
newScroller->immediateMsg = FALSE;
newScroller->releaseMsg = TRUE;
nodePtr = (LinkNode *) newScroller;
}
}
break;
case OTYPE_MX:
{
MXObj *newMX = 0L;
if (GetMem( (void **) &newMX, sizeof(MXObj)))
{
strcpy(newMX->label, "MX:");
newMX->type = OTYPE_MX;
newMX->numBytes = sizeof(MXObj);
newMX->textLabels = gDefaultMX;
newMX->rect.minX = 20;
newMX->rect.minY = 20;
newMX->rect.maxX = newMX->rect.minX + MX_XWIDTH +
CalcMaxWidth(newMX->textLabels) - 1;
newMX->rect.maxY = 52;
newMX->flags = PLACETEXT_RIGHT;
newMX->activeItem = 0;
newMX->extraSpacing = 3;
nodePtr = (LinkNode *) newMX;
}
}
break;
case OTYPE_CheckBox:
{
CheckBoxObj *newCheckBox = 0L;
if (GetMem( (void **) &newCheckBox, sizeof(CheckBoxObj)))
{
strcpy(newCheckBox->label, "Check Box");
newCheckBox->type = OTYPE_CheckBox;
newCheckBox->numBytes = sizeof(CheckBoxObj);
newCheckBox->rect.minX = 20;
newCheckBox->rect.minY = 20;
newCheckBox->rect.maxX = 45;
newCheckBox->rect.maxY = 30;
newCheckBox->flags = PLACETEXT_RIGHT;
newCheckBox->checked = TRUE;
nodePtr = (LinkNode *) newCheckBox;
}
}
break;
case OTYPE_String:
{
StringObj *newString = 0L;
if (GetMem( (void **) &newString, sizeof(StringObj)))
{
strcpy(newString->label, "The String");
strcpy(newString->theChars, "Initial Text");
newString->type = OTYPE_String;
newString->numBytes = sizeof(StringObj);
newString->rect.minX = 20;
newString->rect.minY = 20;
newString->rect.maxX = 99;
newString->rect.maxY = 31;
newString->maxChars = MAX_TEXT_LEN - 1;
newString->flags = PLACETEXT_LEFT;
nodePtr = (LinkNode *) newString;
}
}
break;
case OTYPE_Palette:
{
PaletteObj *newPalette = 0L;
if (GetMem( (void **) &newPalette, sizeof(PaletteObj)))
{
strcpy(newPalette->label, "Color Palette:");
newPalette->type = OTYPE_Palette;
newPalette->numBytes = sizeof(PaletteObj);
newPalette->rect.minX = 20;
newPalette->rect.minY = 20;
newPalette->rect.maxX = 99;
newPalette->rect.maxY = 35;
newPalette->flags = PLACETEXT_ABOVE;
newPalette->depth = 4;
newPalette->firstColor = 1;
newPalette->colorOffset = 0;
newPalette->indicatorWidth = 24L;
newPalette->indicatorHeight = 0L;
nodePtr = (LinkNode *) newPalette;
}
}
break;
case OTYPE_ListView:
{
ListViewObj *newListView = 0L;
if (GetMem( (void **) &newListView, sizeof(ListViewObj)))
{
strcpy(newListView->label, "ListView:");
newListView->type = OTYPE_ListView;
newListView->numBytes = sizeof(ListViewObj);
newListView->rect.minX = 20;
newListView->rect.minY = 40;
newListView->rect.maxX = 120;
newListView->rect.maxY = 100;
newListView->flags = PLACETEXT_ABOVE;
newListView->topItem = 0;
memmove(&newListView->itemList, &gDefaultList, sizeof(List));
/* NewList(&newListView->itemList); */
newListView->readOnly = FALSE;
newListView->scrollWidth = 16;
newListView->stringObj = 0L; // make this point to a string obj for editing
newListView->selectedItem = 0;
newListView->extraSpacing = 1;
nodePtr = (LinkNode *) newListView;
}
}
break;
case OTYPE_Rect:
{
RectObj *newRect = 0L;
if (GetMem( (void **) &newRect, sizeof(RectObj)))
{
newRect->type = OTYPE_Rect;
newRect->color = blackPen;
newRect->numBytes = sizeof(RectObj);
newRect->rect.minX = 20;
newRect->rect.minY = 20;
newRect->rect.maxX = 40;
newRect->rect.maxY = 40;
nodePtr = (LinkNode *) newRect;
}
}
break;
case OTYPE_Line:
break;
case OTYPE_Text:
{
TextObj *newText = 0L;
if (GetMem( (void **) &newText, sizeof(TextObj)))
{
newText->type = OTYPE_Text;
newText->numBytes = sizeof(TextObj);
strcpy(newText->label, "Sample Text");
newText->rect.minX = 20;
newText->rect.minY = 20;
newText->rect.maxX = newText->rect.minX +
TextLength(gWindPtr->RPort, newText->label, strlen(newText->label));
newText->rect.maxY = newText->rect.minY + gWindPtr->RPort->Font->tf_YSize;
newText->flags = PLACETEXT_LEFT;
newText->copyText = FALSE;
newText->border = TRUE;
nodePtr = (LinkNode *) newText;
}
}
break;
case OTYPE_IText:
{
ITextObj *newIText = 0L;
if (GetMem( (void **) &newIText, sizeof(ITextObj)))
{
strcpy(newIText->label, "Sample IText");
newIText->type = OTYPE_IText;
newIText->numBytes = sizeof(ITextObj);
newIText->iText.FrontPen = blackPen;
newIText->iText.BackPen = grayPen;
newIText->iText.DrawMode = JAM2;
newIText->iText.LeftEdge = 1;
newIText->iText.TopEdge = 1;
newIText->iText.ITextFont = &topaz8;
newIText->iText.IText = newIText->label;
newIText->iText.NextText = 0L;
newIText->rect.minX = 20;
newIText->rect.minY = 20;
newIText->rect.maxX = newIText->rect.minX + IntuiTextLength(&newIText->iText);
newIText->rect.maxY = newIText->rect.minY + gWindPtr->RPort->Font->tf_YSize;
nodePtr = (LinkNode *) newIText;
}
}
break;
}
// if (nodePtr)
// nodePtr->itemNum = gNextItemNum++;
if (nodePtr)
AddLink( (void **) &gObjList, nodePtr);
return nodePtr;
}
USHORT CalcMaxWidth(char **theStrings)
{
USHORT width,
maxWidth = 0;
for (; *theStrings; theStrings++)
{
width = TextLength(gWindPtr->RPort, *theStrings, strlen(*theStrings));
maxWidth = (width > maxWidth) ? width : maxWidth;
}
return maxWidth;
}
void DisposeObj( LinkNode *nodePtr )
{
Gadget *gadgetPtr;
USHORT numGadget;
if (nodePtr)
{
if (GetGadgetData(nodePtr, &gadgetPtr, &numGadget, 0L, 0L, 0L))
{
// detach the gadget list from the window,
// and remove the gadget(s) associated with this object from the list
BreakGList(gadgetPtr, numGadget);
UpdateLVConnect(nodePtr, TRUE); // clear any current connections to the string gadg
// re-attach the gadget list to the window
if (!gEditMode)
{
AddGList(gWindPtr, gGadgetContext, -1L, -1L, 0L);
gGadgetsOn = TRUE;
}
if ( ((GadgetObj *)nodePtr)->remKey )
FreeRemember( &((GadgetObj *)nodePtr)->remKey, TRUE );
}
RemLink( (void **) &gObjList, nodePtr);
DropMem( (void **) &nodePtr, nodePtr->numBytes );
}
}
BOOL UpdateLVConnect(LinkNode *nodePtr, BOOL clearIt)
{
ListViewObj *listViewPtr;
// determine if this gadget is attached to a current ListView. If so, disconnect it.
for (listViewPtr=gObjList; listViewPtr; listViewPtr=listViewPtr->next)
{
if (listViewPtr->type == OTYPE_ListView && listViewPtr->stringObj == nodePtr)
{
if (clearIt)
listViewPtr->stringObj = 0L;
if (MakeGadget( (LinkNode *) listViewPtr) != 0)
{
gSelObj = 0L;
DisposeObj(nodePtr);
return FALSE;
}
}
}
return TRUE;
}
/*=======================================================================================*/
/*
MakeGadget - return values 0 = All ok, 1 = object is not gadget type, or
2 = allocations failed
*/
USHORT MakeGadget(LinkNode *nodePtr)
{
struct NewGadget ng;
Gadget *gadgetPtr,
*lastGadget;
Rect *rectPtr;
ULONG flags;
char *labelPtr;
USHORT numGadget;
GadgetObj *objPtr = (GadgetObj *) nodePtr;
BOOL disable;
rectPtr = &objPtr->rect;
if (!GetGadgetData(nodePtr, &gadgetPtr, &numGadget, &flags, &labelPtr, &disable))
return 1;
memset(&ng, 0, sizeof(struct NewGadget));
// remove this gadget from the windowlist and free its memory, if it exists
BreakGList(gadgetPtr, numGadget);
// set up the new gadget structure
ng.ng_LeftEdge = rectPtr->minX;
ng.ng_TopEdge = rectPtr->minY;
ng.ng_Width = rectPtr->maxX - rectPtr->minX + 1;
ng.ng_Height = rectPtr->maxY - rectPtr->minY + 1;
ng.ng_TextAttr = &topaz8;
ng.ng_VisualInfo = gVI;
ng.ng_Flags = flags;
ng.ng_UserData = (APTR) nodePtr;
ng.ng_GadgetID = 0; // nodePtr->itemNum;
ng.ng_GadgetText = labelPtr;
objPtr->disable = disable;
lastGadget = LastGadget();
switch (objPtr->type)
{
case OTYPE_Palette:
{
PaletteObj *newPalette = (PaletteObj *) objPtr;
gadgetPtr = CreateGadget(PALETTE_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newPalette->disable,
GTPA_Depth, newPalette->depth,
GTPA_Color, newPalette->firstColor,
GTPA_ColorOffset, newPalette->colorOffset,
GTPA_IndicatorWidth, newPalette->indicatorWidth,
GTPA_IndicatorHeight, newPalette->indicatorWidth,
TAG_DONE);
}
break;
case OTYPE_String:
{
StringObj *newString = (StringObj *) objPtr;
gadgetPtr = CreateGadget(STRING_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newString->disable,
GTST_String, newString->theChars,
GTST_MaxChars, newString->maxChars,
TAG_DONE);
}
break;
case OTYPE_ListView:
{
ListViewObj *newListView = (ListViewObj *) objPtr;
Gadget *tempPtr = 0L;
if (newListView->stringObj && newListView->stringObj->gadget &&
NodeNum(&gObjList, (LinkNode *) newListView->stringObj) != -1)
tempPtr = newListView->stringObj->gadget;
else
newListView->stringObj = 0L;
gadgetPtr = CreateGadget(LISTVIEW_KIND, lastGadget, &ng,
// GA_Disabled, gDisableAll || newListView->disable,
GTLV_Top, newListView->topItem,
GTLV_Labels, &newListView->itemList,
GTLV_ReadOnly, newListView->readOnly,
GTLV_ScrollWidth, newListView->scrollWidth,
GTLV_ShowSelected, tempPtr,
GTLV_Selected, newListView->selectedItem,
LAYOUTA_SPACING, newListView->extraSpacing,
TAG_DONE);
}
break;
case OTYPE_Button:
{
ButtonObj *newButton = (ButtonObj *) objPtr;
gadgetPtr = CreateGadget(BUTTON_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newButton->disable,
TAG_DONE);
}
break;
case OTYPE_Slider:
{
SliderObj *newSlider = (SliderObj *) objPtr;
gadgetPtr = CreateGadget(SLIDER_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newSlider->disable,
GTSL_Min, newSlider->minLevel,
GTSL_Max, newSlider->maxLevel,
GTSL_Level, newSlider->currentLevel,
GTSL_MaxLevelLen, newSlider->maxChars,
GTSL_LevelFormat, newSlider->format,
GTSL_LevelPlace, newSlider->levelPlace,
GA_IMMEDIATE, newSlider->immediateMsg,
GA_RELVERIFY, newSlider->releaseMsg,
PGA_FREEDOM, newSlider->orientation,
TAG_DONE);
}
break;
case OTYPE_Scroller:
{
ScrollerObj *newScroller = (ScrollerObj *) objPtr;
gadgetPtr = CreateGadget(SCROLLER_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newScroller->disable,
GTSC_Top, newScroller->topItem,
GTSC_Total, newScroller->totalItems,
GTSC_Visible, newScroller->visibleItems,
GTSC_Arrows, newScroller->arrowSize,
PGA_FREEDOM, newScroller->orientation,
GA_IMMEDIATE, newScroller->immediateMsg,
GA_RELVERIFY, newScroller->releaseMsg,
TAG_DONE);
}
break;
case OTYPE_Cycle:
{
CycleObj *newCycle = (CycleObj *) objPtr;
gadgetPtr = CreateGadget(CYCLE_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newCycle->disable,
GTCY_Labels, newCycle->textLabels,
GTCY_Active, newCycle->activeItem,
TAG_DONE);
}
break;
case OTYPE_MX:
{
MXObj *newMX = (MXObj *) objPtr;
gadgetPtr = CreateGadget(MX_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newMX->disable,
GTMX_Labels, newMX->textLabels,
GTMX_Active, newMX->activeItem,
GTMX_Spacing, newMX->extraSpacing,
TAG_DONE);
}
break;
case OTYPE_CheckBox:
{
CheckBoxObj *newCheckBox = (CheckBoxObj *) objPtr;
gadgetPtr = CreateGadget(CHECKBOX_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newCheckBox->disable,
GTCB_Checked, newCheckBox->checked,
TAG_DONE);
}
break;
case OTYPE_Text:
{
TextObj *newText = (TextObj *) objPtr;
ng.ng_GadgetText = 0L; //text obj has no label
/*
newText->rect.maxX = newText->rect.minX +
TextLength(gWindPtr->RPort, newText->label, strlen(newText->label));
*/
gadgetPtr = CreateGadget(TEXT_KIND, lastGadget, &ng,
GA_Disabled, gDisableAll || newText->disable,
GTTX_Text, newText->label,
GTTX_CopyText, newText->copyText,
GTTX_Border, newText->border,
TAG_DONE);
}
break;
}
if (gadgetPtr)
CountGadgets( lastGadget, &objPtr->topGadget, &objPtr->numGadget );
objPtr->gadget = gadgetPtr;
if (!gEditMode)
{
AddGList(gWindPtr, gGadgetContext, -1L, -1L, 0L);
gGadgetsOn = TRUE;
}
// In order to be able to drag the object around without
// interference by its gadgets, we need to actually disable the entire group
// of gadgets associated with the object. The GA_Disabled flag only causes some
// of the gadgets to be disabled. Therefore, we just go in and do it manually.
// gEditMode = !gEditMode; // DoDisable will swap this flag back to original state
// DoDisable(0);
// if (gadgetPtr)
// RefreshGList(gadgetPtr, gWindPtr, NULL, 1L);
// GT_RefreshWindow(gWindPtr, NULL);
if (gadgetPtr)
return 0;
else
return 2;
}
/* ===================================================================================== */
void CountGadgets( Gadget *lastGadget, Gadget **topGadget, USHORT *numGadget )
{
Gadget *tempPtr;
USHORT gadCount = 0;
// count the number of gadgets that CreateGadget() added to the list
// so we know how to deal with them later
*topGadget = lastGadget->NextGadget;
for (tempPtr=*topGadget; tempPtr; tempPtr=tempPtr->NextGadget)
gadCount++;
*numGadget = gadCount;
}
/* ===================================================================================== */
void DoDisable(USHORT code)
{
LinkNode *nodePtr;
Gadget *gadgetPtr;
USHORT i, numGadget;
BOOL disable;
// gEditMode = !gEditMode;
if (!gGadgetsOn)
{
AddGList(gWindPtr, gGadgetContext, -1L, -1L, 0L);
gGadgetsOn = TRUE;
}
gDisableAll = !gDisableAll;
for (nodePtr=gObjList; nodePtr; nodePtr=nodePtr->next)
{
GetGadgetData(nodePtr, &gadgetPtr, &numGadget, 0L, 0L, &disable);
if (gadgetPtr)
{
for (i=0; i<numGadget && gadgetPtr; i++, gadgetPtr=gadgetPtr->NextGadget)
{
if (gadgetPtr && (gDisableAll || disable))
OffGadget(gadgetPtr, gWindPtr, 0L);
else if (gadgetPtr)
OnGadget(gadgetPtr, gWindPtr, 0L);
}
}
}
if (gGadgetsOn && !gEditMode)
{
RemoveGList(gWindPtr, gGadgetContext, -1L);
gGadgetsOn = FALSE;
}
// if (!gEditMode)
// gSelObj = 0L; // Just in case a gadget is currently selected
ReDraw();
}
BOOL GetGadgetData(LinkNode *nodePtr, Gadget **firstGadget, USHORT *numGadget, ULONG *flags,
char **labelPtr, BOOL *disable)
{
switch (nodePtr->type)
{
case OTYPE_Button:
case OTYPE_String:
case OTYPE_Palette:
case OTYPE_CheckBox:
case OTYPE_Cycle:
case OTYPE_ListView:
case OTYPE_MX:
case OTYPE_Scroller:
case OTYPE_Slider:
case OTYPE_Text:
if (firstGadget)
*firstGadget = ( (GadgetObj *) nodePtr)->topGadget;
if (numGadget)
*numGadget = ( (GadgetObj *) nodePtr)->numGadget;
if (flags)
*flags = ( (GadgetObj *) nodePtr)->flags;
if (labelPtr)
*labelPtr = ( (GadgetObj *) nodePtr)->label;
if (disable)
*disable = ( (GadgetObj *) nodePtr)->disable;
break;
default:
if (firstGadget)
*firstGadget = 0L;
if (numGadget)
*numGadget = 0;
if (flags)
*flags = 0L;
if (labelPtr)
*labelPtr = 0L;
if (disable)
*disable = FALSE;
return FALSE;
break;
}
return TRUE;
}
/* ===================================================================================== */
void DoBringFront(USHORT code)
{
if (gSelObj)
{
RemLink( (void **) &gObjList, gSelObj);
AddLink( (void **) &gObjList, gSelObj);
ReDraw();
}
}
/* ===================================================================================== */
void DoSendBack(USHORT code)
{
if (gSelObj)
{
RemLink( (void **) &gObjList, gSelObj);
InsertLink( (void **) &gObjList, gSelObj, 0);
ReDraw();
}
}
/* ===================================================================================== */
/*
Find the last gadget in the linked list, so we can link to it
Note that this needs to be used only because it is possible that the last gadget
created could have been deleted (by the user). Therefore, just saving the last
allocated gadget in a global won't do.
*/
Gadget *LastGadget()
{
Gadget *gadgetPtr;
Forbid(); // just to be safe
for (gadgetPtr=gGadgetContext; gadgetPtr; gadgetPtr=gadgetPtr->NextGadget)
if (!gadgetPtr->NextGadget)
break;
Permit(); // we must be friendly!
return gadgetPtr;
}
/*
BreakGList - Disconnect the gadgets from the window, and remove the specified gadget group
from the linked-list. This routine leaves the gadget list disconnected from
the window.
*/
BOOL BreakGList(Gadget *theGadget, USHORT numGadget)
{
USHORT pos, i;
Gadget *gadgetPtr, *endGadget;
if (gGadgetsOn)
{
pos = RemoveGList(gWindPtr, gGadgetContext, -1L);
gGadgetsOn = FALSE;
}
if (theGadget)
{
// Walk the gadgetlist & find where this gadget is linked in
for (gadgetPtr=gGadgetContext; gadgetPtr; gadgetPtr=gadgetPtr->NextGadget)
{
if (gadgetPtr->NextGadget == theGadget)
{
// now find the end of the gadget grouping that we are going to remove from
// the linked list
endGadget = theGadget;
for (i=1; i<numGadget; i++)
if (endGadget->NextGadget)
endGadget = endGadget->NextGadget;
// now, remove the whole group from the linked-list
// (at this point, theGadget is the first gadget in the group, and
// endGadget is the last gadget in the group)
gadgetPtr->NextGadget = endGadget->NextGadget;
endGadget->NextGadget = 0L;
break;
}
}
// Free up the memory for the gadget group
FreeGadgets(theGadget);
return TRUE;
}
return FALSE;
}